Applying Conditional Logic to Real-World Programming Problems

Course: Python Programming

Topic: Applying Conditional Logic to Real-World Programming Problems

Course Link: Python Training at JustAcademy

Demo Link: Register for a Course Demo

Python Reference: Python Control Flow Documentation

1. Introduction to Conditional Logic

Conditional logic is a fundamental programming concept that allows a program to make decisions based on specific conditions. It determines which instructions should execute depending on data, user input, calculations, and the current state of an application.

In real-world software development, programs rarely perform exactly the same operations in every situation. An e-commerce website checks whether a product is available before processing an order. A banking application checks whether an account has sufficient funds before allowing a withdrawal. A student management system evaluates marks to determine a result.

Python provides conditional statements such as if, if-else, and if-elif-else to implement this decision-making logic. Developers can combine these statements with comparison operators, logical operators, variables, functions, and exception handling to solve practical programming problems.

Example

account_balance = 5000
withdrawal_amount = 2000

if account_balance >= withdrawal_amount:
    print("Withdrawal request can proceed.")

print("Transaction check completed.")

Output:

Withdrawal request can proceed.
Transaction check completed.

The program compares the account balance with the requested withdrawal amount. Since the balance is sufficient, the conditional message is displayed.

2. Learning Objectives

After completing this topic, learners will be able to:

• Understand the importance of conditional logic in programming.
• Translate real-world requirements into programming conditions.
• Use comparison and logical operators effectively.
• Implement decisions using if, if-else, and if-elif-else.
• Apply nested conditions to dependent decisions.
• Validate user input before processing it.
• Develop practical programs for shopping, education, banking simulations, and other scenarios.
• Identify logical errors and test boundary conditions.
• Improve code readability and maintainability.
• Understand why application logic often requires more than a simple condition.

3. Understanding the Main Components of Conditional Logic

3.1 Conditions

A condition is an expression that Python evaluates to determine whether a particular branch should execute. Conditions commonly produce the Boolean values True or False.

age = 21

if age >= 18:
    print("Age requirement satisfied.")

3.2 Comparison Operators

Comparison operators compare values and help establish the conditions required by a program.

3.3 Logical Operators

Logical operators combine or modify conditions.

3.4 Decision-Making Statements

• if: Executes a block when its condition is true.
• if-else: Chooses between two alternative blocks.
• if-elif-else: Selects from multiple alternative conditions.
• Nested conditions: Evaluate dependent decisions inside other conditional blocks.

4. A Step-by-Step Method for Solving Real-World Problems

Before writing code, understand the problem and identify the rules that control its outcomes. A structured approach reduces logical errors.

1. Understand the requirement: Identify the decision the program must make.
2. Identify the inputs: Determine which values are required, such as price, age, quantity, or status.
3. Define the rules: Specify the conditions that determine each possible outcome.
4. Validate the inputs: Check types, permitted ranges, and missing values.
5. Choose the conditional structure: Use an appropriate if, if-else, elif, or nested structure.
6. Write the program: Translate each rule into Python code.
7. Test the outcomes: Try normal inputs, boundary values, and invalid inputs.
8. Review the logic: Check whether every relevant situation produces an appropriate result.

Example: Identifying a Requirement

Problem: A store provides free delivery when the order total is at least ₹1,000.

Input: Order total.

Condition: Order total is greater than or equal to 1,000.

Output: Display a free-delivery message when the condition is satisfied.

order_total = 1200

if order_total >= 1000:
    print("Free delivery is available.")

5. Real-World Problem 1: Student Grade Calculation

Educational applications frequently use conditional logic to classify marks, determine pass or fail results, and assign grades.

Problem Statement

Write a program that accepts marks between 0 and 100, checks whether the student has passed, and assigns a grade according to predefined thresholds.

Python Code

try:
    marks = float(input("Enter marks out of 100: "))

    if not 0 <= marks <= 100:
        print("Marks must be between 0 and 100.")
    elif marks >= 90:
        print("Grade: A")
    elif marks >= 80:
        print("Grade: B")
    elif marks >= 70:
        print("Grade: C")
    elif marks >= 40:
        print("Grade: D")
    else:
        print("Result: Fail")

except ValueError:
    print("Please enter a valid numeric value.")

Sample Output

Enter marks out of 100: 85
Grade: B

Explanation

• The program accepts marks from the user.
• The first condition validates the permitted range.
• The elif statements check grade thresholds in descending order.
• The first matching branch executes.
• The final else handles marks below 40.
• The try-except block handles text or other input that cannot be converted to a number.

The grading thresholds are illustrative and can be modified to match an institution's actual grading policy.

6. Real-World Problem 2: Shopping Discount Calculator

Online stores use conditional logic to calculate discounts based on order values, membership status, and promotional eligibility.

Problem Statement

Create a program that applies a 10% discount when the purchase total is at least ₹2,000. Otherwise, no discount is applied.

Python Code

try:
    purchase_amount = float(input("Enter purchase amount: "))

    if purchase_amount < 0:
        print("Purchase amount cannot be negative.")
    elif purchase_amount >= 2000:
        discount = purchase_amount * 0.10
        final_amount = purchase_amount - discount

        print(f"Discount: ₹{discount:.2f}")
        print(f"Final amount: ₹{final_amount:.2f}")
    else:
        print("No discount applicable.")
        print(f"Final amount: ₹{purchase_amount:.2f}")

except ValueError:
    print("Please enter a valid amount.")

Sample Output

Enter purchase amount: 2500
Discount: ₹250.00
Final amount: ₹2250.00

Explanation

• The input is converted into a floating-point number.
• Negative purchase amounts are rejected.
• Orders of ₹2,000 or more receive a 10% discount.
• Smaller orders retain the original amount.
• Formatted strings display the calculated amounts to two decimal places.

7. Real-World Problem 3: ATM Withdrawal Simulation

A banking simulation can use conditional logic to demonstrate withdrawal validation. This example is for learning purposes and is not a production banking system.

Problem Statement

Check whether the withdrawal amount is positive and whether sufficient balance is available before simulating a withdrawal.

Python Code

balance = 10000

try:
    amount = float(input("Enter withdrawal amount: "))

    if amount <= 0:
        print("Withdrawal amount must be positive.")
    elif amount > balance:
        print("Insufficient balance.")
    else:
        balance = balance - amount
        print("Withdrawal successful.")
        print(f"Remaining balance: ₹{balance:.2f}")

except ValueError:
    print("Please enter a valid amount.")

Sample Output

Enter withdrawal amount: 2500
Withdrawal successful.
Remaining balance: ₹7500.00

Explanation

• The initial balance is stored in a variable.
• The program rejects zero or negative withdrawal amounts.
• The next condition checks whether the requested amount exceeds the balance.
• If the request is valid, the simulated balance is updated.

Real banking systems require authentication, authorization, transaction locking, persistent account records, audit logs, and secure transaction processing. A local variable alone does not provide these protections.

8. Real-World Problem 4: Login Validation

Applications use conditions to check whether required login information has been provided and whether submitted credentials match the expected values.

Python Code

stored_username = "student"
stored_password = "demo123"

username = input("Enter username: ")
password = input("Enter password: ")

if not username or not password:
    print("Username and password are required.")
elif username == stored_username and password == stored_password:
    print("Login successful.")
else:
    print("Invalid username or password.")

Sample Output

Enter username: student
Enter password: demo123
Login successful.

Explanation

• The program collects the username and password.
• The first condition checks whether either field is empty.
• The next condition checks whether both values match the sample credentials.
• If the values do not match, the final branch displays an error message.

Security note: Hardcoded credentials are suitable only for simple demonstrations. Real applications should use secure password hashing, trusted authentication systems, protected credential storage, and appropriate access controls.

9. Real-World Problem 5: Product Inventory Management

Inventory applications use conditional logic to determine whether products are available and whether stock levels need attention.

Problem Statement

Display an appropriate inventory message based on the available quantity.

Python Code

try:
    stock = int(input("Enter available stock quantity: "))

    if stock < 0:
        print("Stock quantity cannot be negative.")
    elif stock == 0:
        print("Product is out of stock.")
    elif stock <= 5:
        print("Low stock. Consider restocking.")
    else:
        print("Product is available.")

except ValueError:
    print("Please enter a valid whole number.")

Sample Output

Enter available stock quantity: 3
Low stock. Consider restocking.

Explanation

• Negative quantities are rejected.
• Zero indicates that no units are available.
• Quantities from 1 to 5 trigger a low-stock warning.
• Quantities above 5 are classified as available stock.

The threshold of five units is an example and can be adjusted for each product.

10. Real-World Problem 6: Electricity Bill Calculation

Conditional logic can calculate charges using different rates for different consumption ranges. The following simplified example uses progressive billing: each rate applies only to the units within its stated range.

Example Tariff

Python Code

try:
    units = int(input("Enter electricity units consumed: "))

    if units < 0:
        print("Units cannot be negative.")
    elif units <= 100:
        bill = units * 2
        print(f"Electricity bill: ₹{bill:.2f}")
    elif units <= 200:
        bill = (100 * 2) + ((units - 100) * 3)
        print(f"Electricity bill: ₹{bill:.2f}")
    else:
        bill = (100 * 2) + (100 * 3) + ((units - 200) * 5)
        print(f"Electricity bill: ₹{bill:.2f}")

except ValueError:
    print("Please enter a valid whole number.")

Sample Output

Enter electricity units consumed: 250
Electricity bill: ₹650.00

Explanation

For 250 units, the first 100 units cost ₹200, the next 100 cost ₹300, and the remaining 50 units cost ₹250. The total is ₹750.

Important correction to the sample calculation: The code above calculates ₹750 for 250 units. The expected output should therefore be:

Enter electricity units consumed: 250
Electricity bill: ₹750.00

This is a simplified tariff model. Actual electricity bills may include fixed charges, taxes, subsidies, and region-specific rates.

11. Real-World Problem 7: Shipping Cost Calculator

An e-commerce application may determine shipping charges according to the order value and delivery option.

Python Code

try:
    order_amount = float(input("Enter order amount: "))
    express = input("Express delivery? (yes/no): ").strip().lower()

    if order_amount < 0:
        print("Order amount cannot be negative.")
    elif express not in ("yes", "no"):
        print("Please enter yes or no.")
    elif order_amount >= 1500:
        if express == "yes":
            shipping = 100
        else:
            shipping = 0

        print(f"Shipping charge: ₹{shipping:.2f}")
        print(f"Total: ₹{order_amount + shipping:.2f}")
    else:
        if express == "yes":
            shipping = 150
        else:
            shipping = 60

        print(f"Shipping charge: ₹{shipping:.2f}")
        print(f"Total: ₹{order_amount + shipping:.2f}")

except ValueError:
    print("Please enter a valid order amount.")

Explanation

• The program validates the order amount and delivery choice.
• Orders of ₹1,500 or more follow one shipping policy.
• Smaller orders follow another shipping policy.
• Nested conditions determine the charge based on the delivery option.
• The final total combines the order amount and shipping charge.

The shipping fees are illustrative and should be replaced with the business's actual delivery rules.

12. Real-World Problem 8: Employee Bonus Eligibility

Organizations may use conditional rules to determine whether employees qualify for a bonus based on tenure and performance.

Python Code

try:
    years = float(input("Enter years of service: "))
    rating = float(input("Enter performance rating from 1 to 5: "))

    if years < 0:
        print("Years of service cannot be negative.")
    elif not 1 <= rating <= 5:
        print("Rating must be between 1 and 5.")
    elif years >= 3 and rating >= 4:
        print("Eligible for bonus consideration.")
    else:
        print("Bonus requirements not satisfied.")

except ValueError:
    print("Please enter valid numeric values.")

Explanation

The program checks the input ranges and then verifies both eligibility requirements. The employee must have at least three years of service and a performance rating of at least four.

The criteria are illustrative; real bonus decisions depend on the organization's policies and employment agreements.

13. Real-World Problem 9: Age-Based Ticket Pricing

Ticketing systems can use conditional logic to calculate prices according to age categories.

Python Code

try:
    age = int(input("Enter your age: "))

    if age < 0:
        print("Age cannot be negative.")
    elif age <= 5:
        price = 0
        print("Category: Young child")
        print(f"Ticket price: ₹{price}")
    elif age <= 17:
        price = 100
        print("Category: Child or teenager")
        print(f"Ticket price: ₹{price}")
    elif age <= 59:
        price = 200
        print("Category: Adult")
        print(f"Ticket price: ₹{price}")
    else:
        price = 120
        print("Category: Senior")
        print(f"Ticket price: ₹{price}")

except ValueError:
    print("Please enter a valid whole number.")

Explanation

The program checks age ranges in ascending order and assigns a price to the first matching category. The ticket prices and age bands are illustrative and can be modified for a particular service.

14. Real-World Problem 10: Checking Delivery Eligibility

A delivery application may check whether a destination is supported and whether the order meets a minimum purchase requirement.

Python Code

supported_areas = ["Mumbai", "Thane", "Navi Mumbai"]

area = input("Enter delivery area: ").strip().title()

try:
    order_amount = float(input("Enter order amount: "))

    if order_amount < 0:
        print("Order amount cannot be negative.")
    elif area in supported_areas:
        if order_amount >= 500:
            print("Delivery is available.")
        else:
            print("Minimum order amount is ₹500.")
    else:
        print("Delivery is not available in this area.")

except ValueError:
    print("Please enter a valid order amount.")

Explanation

• The program stores supported locations in a list.
• The user's area is normalized using strip() and title().
• The first condition checks the order amount.
• The next condition checks whether the destination is supported.
• The nested condition verifies the minimum order value.

The supported locations are examples. A real service should use a reliable delivery-zone database and appropriate address validation.

15. Handling Invalid Input and Edge Cases

Real-world programs must consider invalid, missing, unexpected, and boundary values. A condition alone cannot safely handle every possible input. Input conversion, validation, and exception handling may also be necessary.

Example: Safe Age Input

try:
    age = int(input("Enter your age: "))

    if age < 0:
        print("Age cannot be negative.")
    elif age < 18:
        print("Below 18.")
    else:
        print("18 or older.")

except ValueError:
    print("Enter a valid whole number.")

Important Edge Cases

• Zero: Check whether zero is a valid value for the problem.
• Negative values: Reject them when the business rule requires non-negative values.
• Boundary values: Test values immediately below, equal to, and above thresholds.
• Empty strings: Check whether required text fields have been provided.
• Unexpected text: Handle failed numeric conversions with suitable exception handling.
• Floating-point values: Use appropriate numeric types and avoid assuming every input is an integer.
• Missing data: Determine what should happen when required information is unavailable.

16. Common Conditional Logic Mistakes

16.1 Using Assignment Instead of Equality Comparison

Incorrect:

if age = 18:
    print("Age is 18.")

Correct:

if age == 18:
    print("Age is 18.")

The double equals operator checks equality, while a single equals sign assigns a value.

16.2 Incorrect Range Conditions

Incorrect:

age = 25

if age >= 18 or age <= 60:
    print("Eligible")

This condition is true for almost every integer because either the first or second comparison will usually be true. If the requirement is an age from 18 through 60, use and.

Correct:

if 18 <= age <= 60:
    print("Eligible")

16.3 Incorrect Branch Order

When checking grade thresholds, place higher thresholds before lower ones. Otherwise, a broad condition can match first and prevent a more specific branch from being reached.

Incorrect:

marks = 95

if marks >= 40:
    print("Pass")
elif marks >= 90:
    print("Excellent")

The program prints "Pass" because the first condition is already true.

Correct:

if marks >= 90:
    print("Excellent")
elif marks >= 40:
    print("Pass")
else:
    print("Fail")

16.4 Forgetting Input Conversion

The input() function returns text. Convert numeric input to the appropriate type before performing numeric comparisons.

16.5 Duplicating Business Rules

If the same rule is repeated throughout a program, updating it becomes difficult. Store reusable thresholds in variables or functions when appropriate.

16.6 Ignoring Unhandled Situations

Consider all expected outcomes. For example, a delivery program should define what happens when an area is unsupported rather than only handling supported locations.

17. Improving Conditional Logic with Functions

As programs grow, moving business rules into functions makes the code easier to test, reuse, and maintain.

Example: Discount Function

def calculate_discount(amount):
    if amount < 0:
        raise ValueError("Amount cannot be negative.")

    if amount >= 2000:
        return amount * 0.10

    return 0


try:
    total = 2500
    discount = calculate_discount(total)
    final_total = total - discount

    print(f"Discount: ₹{discount:.2f}")
    print(f"Final total: ₹{final_total:.2f}")

except ValueError as error:
    print(error)

Output:

Discount: ₹250.00
Final total: ₹2250.00

The function separates the discount rule from the rest of the application. The same function can be reused by a shopping cart, billing screen, or order-processing module.

18. Mini Project: Simple Shopping Checkout System

Project objective: Create a checkout program that calculates a subtotal, applies a discount, adds shipping fees, and displays the final amount.

Business Rules

• The quantity must be greater than zero.
• The unit price cannot be negative.
• Orders of at least ₹2,000 receive a 10% discount.
• Orders below ₹1,000 have a shipping charge of ₹80.
• Orders of ₹1,000 or more have free standard shipping.

Python Code

try:
    unit_price = float(input("Enter unit price: "))
    quantity = int(input("Enter quantity: "))

    if unit_price < 0:
        print("Unit price cannot be negative.")
    elif quantity <= 0:
        print("Quantity must be greater than zero.")
    else:
        subtotal = unit_price * quantity

        if subtotal >= 2000:
            discount = subtotal * 0.10
        else:
            discount = 0

        discounted_total = subtotal - discount

        if discounted_total < 1000:
            shipping = 80
        else:
            shipping = 0

        final_total = discounted_total + shipping

        print(f"Subtotal: ₹{subtotal:.2f}")
        print(f"Discount: ₹{discount:.2f}")
        print(f"Shipping: ₹{shipping:.2f}")
        print(f"Final total: ₹{final_total:.2f}")

except ValueError:
    print("Please enter a valid price and whole-number quantity.")

Sample Output

Enter unit price: 600
Enter quantity: 4
Subtotal: ₹2400.00
Discount: ₹240.00
Shipping: ₹0.00
Final total: ₹2160.00

Project Explanation

• The program collects the unit price and quantity.
• It validates both inputs.
• The subtotal is calculated by multiplying price by quantity.
• A conditional statement determines whether a discount applies.
• The discounted amount is used to determine shipping charges.
• The final total combines the discounted amount and shipping fee.

This project demonstrates how multiple business rules can be combined to create a practical checkout workflow.

19. Practice Exercises

Exercise 1: Pass or Fail

Write a program that accepts marks and displays whether a student has passed or failed.

Exercise 2: Grade Classification

Extend the first exercise to assign grades using multiple thresholds.

Exercise 3: Discount Eligibility

Apply a discount when a customer's purchase reaches a specified amount.

Exercise 4: ATM Withdrawal

Check whether a withdrawal amount is positive and whether sufficient balance is available.

Exercise 5: Inventory Alert

Display different messages for out-of-stock, low-stock, and adequately stocked products.

Exercise 6: Shipping Calculator

Calculate shipping charges based on the order amount and delivery method.

Exercise 7: Login Validation

Check whether the required login fields are present and simulate a credential comparison.

Exercise 8: Electricity Bill

Calculate a bill using progressive unit ranges and reject negative consumption.

Exercise 9: Employee Bonus

Check years of service and performance rating before displaying bonus eligibility.

Exercise 10: Delivery Area Checker

Check whether an entered location belongs to a list of supported delivery areas.

20. Interview Questions and Answers

Q1. What is conditional logic?

Conditional logic is the process of making decisions in a program based on whether specified conditions are satisfied.

Q2. Which statements are used for conditional logic in Python?

The main conditional statements are if, if-else, and if-elif-else. Conditional statements can also be nested when decisions depend on earlier conditions.

Q3. What is the difference between and and or?

and requires both conditions to be true, whereas or requires at least one condition to be true.

Q4. Why is input validation important?

Input validation helps prevent invalid data from being processed and makes program behavior more predictable.

Q5. What is a boundary condition?

A boundary condition is a value at or near the limit of a rule, such as exactly 40 marks for a pass threshold.

Q6. Why should elif conditions be ordered carefully?

Python executes the first matching branch. If a broad condition comes before a more specific condition, the intended branch may never execute.

Q7. How can conditional logic be tested?

Test normal inputs, invalid inputs, boundary values, and every expected branch. Automated unit tests can help repeat these checks reliably.

Q8. How can complex conditional logic be improved?

Use descriptive names, well-defined functions, clear conditions, consistent formatting, and fewer unnecessary nesting levels.

Q9. What is the role of exception handling?

Exception handling allows a program to respond to runtime errors, such as invalid numeric conversion, instead of terminating unexpectedly.

Q10. Can conditional logic be used in business applications?

Yes. It is commonly used for pricing, eligibility checks, validation, inventory, access control, billing, and workflow decisions.

21. Best Practices for Real-World Conditional Logic

• Translate business requirements into clear, testable rules.
• Validate user input before performing calculations.
• Use the appropriate data type for each value.
• Order conditions carefully when thresholds overlap.
• Test exact boundary values and unexpected inputs.
• Use functions to separate business rules from input and output operations.
• Avoid unnecessary nested conditions.
• Use meaningful names for variables and constants.
• Keep security-sensitive decisions on trusted application systems.
• Do not rely on a demonstration program as a replacement for production validation, authorization, or transaction safeguards.
• Use automated tests for important business rules.
• Document unusual rules and assumptions.

22. Quick Revision Notes

• Conditional logic allows a program to make decisions.
• The if statement executes code when a condition is true.
• The else branch handles the alternative when an if condition is false.
• The elif keyword supports multiple alternatives.
• Nested conditions represent dependent decisions.
• Comparison operators compare values.
• Logical operators combine or reverse conditions.
• Input validation checks whether values meet expected requirements.
• Exception handling deals with errors such as invalid numeric input.
• Functions help organize reusable business rules.
• Testing boundary values helps reveal logical mistakes.

23. Conclusion

Applying conditional logic to real-world programming problems is an essential Python skill. It allows developers to translate business rules into executable instructions and build applications that respond appropriately to different inputs and situations.

By practising examples involving student grades, discounts, banking simulations, inventory, billing, shipping, and eligibility checks, learners develop a practical understanding of how conditions work together. Input validation, appropriate branch ordering, exception handling, and systematic testing further improve program reliability.

As you advance, practise converting written requirements into clear conditions, placing reusable rules inside functions, and testing every possible outcome. These skills provide a strong foundation for developing larger Python applications.

24. Learn More with JustAcademy

Continue learning Python programming through these resources:

• Explore Python Training at JustAcademy
• Register for a JustAcademy Course Demo
• Visit the JustAcademy Homepage